Aggregation

Aggregation

• If a class have an Object reference as its data member then it is known as Aggregation.
• Aggregation represents HAS-A relationship.
• Advantage of Aggregation is that we can reuse our existing code.

        class Employee
        {
            int id;
            String name;
            Address homeAddress ;
            Address officeAddress; //Address is a class
        }
        Class Customer
        {
            String name ;
            Address address ;
        }

  class Address 
 { 
    String city,state,country; 
    public Address(String ct,String st,String cr)
    { 
        city=ct; 
        state=st; 
        country=cr; 
    } 
 }
 class Customer 
 { 
    String name; 
    Address address; 
    public void display()
    { 
        System.out.println(name); 
        System.out.println(address.city); 
        System.out.println(address.state); 
        System.out.println(address.country); 
    } 
    public Customer(String name,Address ad) 
    { 
        this.name=name; 
        this.address=ad; 
    } 
 }
 class demo
 {
    public static void main(String args[])
    {
        Address adr1=new Address("lucknow","UP","india"); 
        Customer a=new Customer("Amit Jain",adr1); 
        a.display();
    }
  }

Amit Jain
lucknow 
UP 
india

finalize method

• The finalize method is called when an dead object is about to get garbage collected. That can be at any time after it has become eligible for garbage collection.
• Abandoned objects or dead objects are those objects which does not have live references.
• Garbage collector thread before removing out an abandoned object, it calls finalize () method of that object.
• You can override the finalize () method to perform those operations you want to do before an object is destroyed.
• After finalize () method is executed, object is destroyed from the memory.

protected void finalize() throws Throwable
{
    //resource closing operations 
}

  class Person
 {
    protected String name,city;
    public Person(String nm,String ct)
    {
        name = nm;
        city = ct;
    }
    protected void finalize() throws Throwable
    {
        System.out.println("Finalize Method executed");
    }
 }
 class demo
 {
    public static void main(String args[])
    {
        Person a=new Person("Amit","Amravati");
        Person b=new Person("Nitin","Nagpur");
        a=b; 
 
        // object a will become abandoned
        // as a is referring to object b
        //Calling garbage collector thread explicitly
        System.gc(); 
        System.out.println("done");
    }
  }

done 

Finalize Method executed

Private constructor

• The private constructor is useful in case we want to restrict the object creation.
• There are two possible reasons why one would want to use a private constructor
• The first is that you don't want any objects of your class to be created at all.
• The second is that you only want objects to be created internally - as in only created in your class.
• For example, Singleton pattern can be implemented using a private constructor.

  class MyClass 
 {
    private static MyClass obj;
    private MyClass()
    { }
    public static MyClass getObject()
    {
        if(obj==null)
        {
            obj=new MyClass();
        }
        return obj;
    }
 }
 class demo
 {
    public static void main(String args[])
    {
        MyClass a1=MyClass.getObject();
        MyClass a2=MyClass.getObject();
        System.out.println(a1);
        System.out.println(a2);
    }
  }

MyClass@15db9742
MyClass@15db9742

1. We want to create only one object of MyClass.
2. So we have defined a private constructor in the class .
3. Due to this private constructor user will not be able to create object from outside the class.
4. To get object of this class we have provided a static method getOjbect( ).
5. This method internally create an object and returns it if object is not already created else it returns existing object.
6. This concept of creating only one object of a class is called as Singleton Pattern